Data-intensive computing operations may be executed in a fast and efficient manner by using a plurality of processing cores to execute the computing operations in a parallel or overlapping fashion. For example, a query may be executed against a relational database, and each of a pair of processing cores may be used to search half of the relational database to thereby obtain a query result for the database as a whole. More generally, any number of available cores may be used in parallel by defining sub-portions of the computing operation(s) and assigning one or more of the cores to each one of the sub-portions. The sub-portions may be defined, e.g., by partitioning data to be queried, and/or by defining individual sub-tasks of the overall computing operation(s).
Thus, in certain types of computing operations, it may be necessary or advantageous to execute or otherwise process a query by defining sub-tasks of the query, so that each sub-task of the query has an intermediate input and output, while the final sub-task(s) outputs the final query result. In such cases, it may often occur that a quantity and/or type of data being queried, and/or of desired query result(s), may benefit from storing the intermediate outputs within buffers during the query processing. For example, for very large quantities of data, it may be impractical or impossible to move the data from one storage location to another within a desired time frame. Consequently, instead, a query sub-task may write intermediate results as output to a buffer, and a subsequent query sub-task may read the intermediate results as input from the buffer. In this way, the intermediate data may stay within the buffer during processing.
Problematically, it may occur that the intermediate results are written to such a buffer faster (or slower) than the intermediate results may be read therefrom. In such cases, the buffer may, over time, become completely full or completely empty. In such cases, cores dedicated to related processing may become idle, and/or may be switched from writing to the buffer to reading therefrom (or vice-versa). However, occurrences either of idle cores and/or of excessive switching of cores between query sub-tasks are generally associated with inefficiencies in the query processing, and with a reduced speed of obtaining a final query result.